
(defvar mh-folder-mode-hook nil "\
*Invoked in mh-folder-mode on a new folder.")

(defvar mh-letter-mode-hook nil "\
*Invoked in mh-letter-mode on a new letter.")

(defvar mh-compose-letter-hook nil "\
*Invoked in mh-compose-and-send-mail on an outgoing letter.  It is passed
three arguments: TO recipients, SUBJECT, and CC recipients.")

(defvar mh-clean-message-header nil "\
*Non-nil means remove invisible header lines or only show visible header
lines in messages.")

(defvar mh-visible-headers nil "\
*If non-nil, it contains a regexp specifying the headers that are shown in
a message.")

(defvar mh-use-mhl nil "\
*Non-nil means use mhl to format messages.")

(defvar mh-lpr-command-format "lpr -p -J '%s'" "\
*Format for Unix command line to print a message. The format should be
a unix command line, with the string \"%s\" where the folder and message
number should appear.")

(defvar mh-summary-height 4 "\
*Number of lines in summary window.")

(defvar mh-ins-buf-prefix ">> " "\
*String to put before each non-blank line of the the current message
as it is inserted in an outgoing letter.")

(defvar mh-cmd-note 4 "\
Offset to insert notation")

(defvar mh-invisible-headers "^Received: \\|^Message-Id: \\|^Remailed-\\|^Via: \\|^Mail-from: \\|^Return-Path: \\|^In-Reply-To: \\|^Resent-" "\
Regexp specifying headers that are not to be shown.")

(defvar mh-rejected-letter-start "^   ----- Unsent message follows -----$" "\
Regexp specifying the beginning of the wrapper around a letter returned
by the mail system.")

(defvar mh-good-msg-regexp "^....[^D^]" "\
Regexp specifiying the scan lines that are 'good' messages")

(defvar mh-redist-full-contents t "\
Non-nil if MH `dist' command wants the whole letter to redistribute (i.e.,
MH.6).  Nil otherwise.")

(defvar mh-user-path "" "\
User's mail folder.")

(defvar mh-last-destination nil "\
Destination of last " move " command.")

(defvar mh-folder-mode-map (make-sparse-keymap) "\
Keymap for MH folders.")

(defvar mh-letter-mode-map (make-sparse-keymap) "\
Keymap for composing mail.")

(defvar mh-pick-mode-map (make-sparse-keymap) "\
Keymap for searching folder.")

(defvar mh-folder-list nil "\
List of folder names for completion.")

(defmacro push (v l) (byte-code "��	EE�" [l v setq cons] 5))

(defmacro caar (l) (byte-code "��DD�" [l car] 3))

(defmacro cadr (l) (byte-code "��DD�" [l car cdr] 3))

(defmacro cdar (l) (byte-code "��DD�" [l cdr car] 3))

(defmacro cddr (l) (byte-code "��DD�" [l cdr] 3))

(defmacro when (pred &rest body) (byte-code "�	BD�" [pred body cond] 3))

(defun mapc (func list) (byte-code "� �	@\"�A���  �" [list func funcall] 4))

(defun mh-rmail (&optional arg) "\
Inc(orporate) new mail (no arg) or scan a MH mail box (arg given).
This front end uses the MH mail system, which uses different conventions
from the usual mail system." (interactive "P") (byte-code "��� �� ��!� � �" [arg nil mh-find-path call-interactively mh-visit-folder mh-inc-folder] 4))

(defun mh-smail nil "\
Send mail using the MH mail system." (interactive) (byte-code "��� ���!�" [nil mh-find-path call-interactively mh-send] 3))

(defun mh-smail-other-window nil "\
Send mail in other window using the MH mail system." (interactive) (byte-code "��� ���!�" [nil mh-find-path call-interactively mh-send-other-window] 3))

(defun mh-answer (prefix-provided msg) "\
Answer a MESSAGE (default: displayed message).
If (optional) prefix argument provided, then include the message in the reply." (interactive (byte-code "��!D�" [current-prefix-arg t mh-get-msg-num] 3)) (byte-code "Ĉ������$�!
	��!���\"�' ��\"�F ���������&�A ��D\"\"�� ��\"�i ���������&�d ��D\"\"�� ��\"�� ���������&�� ��D\"\"�����\"\"����\"!�� ���!���!��!��!eb���!�?�� �	#����#���!�����&+,)�" [current-prefix-arg t minibuffer-help-form reply-to nil msg-filename msg folder mh-current-folder show-buffer mh-show-buffer prefix-provided mh-user-path to subject cc "from => Sender
  to => Sender and primary recipients
  cc => Sender and all recipients" completing-read "Reply to whom: " (("from") ("to") ("cc")) mh-msg-filename message "Composing a reply..." equal "from" "" apply mh-exec-cmd nconc list "repl" "-build" "-nodraftfolder" "-nocc" "all" "-filter" "mhl.reply" "to" "-cc" "cc" mh-read-draft "reply" format "%sreply" delete-file delete-other-windows set-buffer-modified-p mh-get-field "To:" "Subject:" "Cc:" mh-goto-header-end 1 mh-display-msg mh-add-msg-to-seq "answered" "Composing a reply...done" mh-compose-and-send-mail "-" "Replied:"] 38))

(defun mh-burst-digest nil "\
Burst apart the current message, which should be a digest.  Message is
replaced by its table of contents and the letters from the digest are inserted
into the folder after that message." (interactive) (byte-code "ƈ��!
� � ��!� �!� � ���!����$����\"\"���!)�" [digest t mh-delete-list mh-move-list mh-current-folder mh-first-msg-num nil mh-get-msg-num yes-or-no-p "Process outstanding commands (or lose them)? " mh-process-commands mh-undo-folder message "Bursting digest..." mh-exec-cmd "burst" "-inplace" mh-scan-folder format "%d-last" "Bursting digest...done"] 11))

(defun mh-copy-msg (prefix-provided msg-or-seq dest) "\
Copy specified MESSAGE(s) (default: displayed message) to another
FOLDER without deleting them.
If (optional) prefix argument supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "� ��	\"� ��!����#E�" [current-prefix-arg mh-narrowed-to-seq t mh-read-seq "Copy" mh-get-msg-num mh-prompt-for-folder "Copy to" ""] 8)) (byte-code "Ȉ����&�� ��#�  ��#�" [current-prefix-arg mh-narrowed-to-seq t msg-or-seq mh-current-folder dest prefix-provided mh-cmd-note nil mh-exec-cmd "refile" "-link" "-src" mh-notate-seq 67 mh-notate] 7))

(defun mh-delete-msg (prefix-provided msg-or-seq) "\
Mark the specified MESSAGE(s) (default: displayed message) for later
deletion.
If (optional) prefix argument supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "� ��	\"� ��!D�" [current-prefix-arg mh-narrowed-to-seq t mh-read-seq "Delete" mh-get-msg-num] 4)) (byte-code "ň� ��\"� �!�� �" [current-prefix-arg mh-narrowed-to-seq t prefix-provided msg-or-seq nil mh-map-to-seq-msgs mh-delete-a-msg mh-next-msg] 4))

(defun mh-delete-msg-from-seq (prefix-provided msg-or-seq &optional from-seq) "\
Delete MESSAGE (default: displayed message) from SEQUENCE.
If (optional) prefix argument supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "	� ��
\"� ��!?� ��
\"E)�" [argp current-prefix-arg mh-narrowed-to-seq t mh-read-seq "Delete" mh-get-msg-num "Delete from"] 7)) (byte-code "ǈ� �!� �\"�� �" [argp current-prefix-arg mh-narrowed-to-seq t prefix-provided msg-or-seq from-seq nil mh-remove-seq mh-remove-msg-from-seq mh-next-msg] 4))

(defun mh-execute-commands nil "\
Process outstanding delete and move requests." (interactive) (byte-code "ň� � ���	!)�� �É�ɉ�� �" [mh-narrowed-to-seq mh-current-folder mh-summarize t mode-name nil mh-widen mh-process-commands delete-other-windows "Mh-Summary" mh-make-folder-mode-line] 5))

(defun mh-extract-rejected-mail (msg) "\
Extract a letter returned by the mail system (default: displayed message)
and make it resendable." (interactive (byte-code "��!C�" [t mh-get-msg-num] 2)) (byte-code "ƈ
����#\"�eb��!���!��e`\"��e��#�eb���!���	��!��!��!&)�" [t from-folder mh-current-folder mh-folder-filename msg mh-rejected-letter-start nil mh-read-draft "extraction" format "%s%d" re-search-forward forward-char 1 kill-region mh-clean-msg-header "^Date:\\|^Received:\\|^Message-Id:\\|^From:" set-buffer-modified-p mh-compose-and-send-mail "" mh-get-field "To" "From" "cc"] 17))

(defun mh-forward (prefix-provided msg-or-seq to cc) "\
Forward MESSAGE(s) (default: displayed message).
If (optional) prefix argument supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "� ��	\"� ��!��!��!F�" [current-prefix-arg mh-narrowed-to-seq t mh-read-seq "Forward" mh-get-msg-num read-string "To: " "Cc: "] 8)) (byte-code "Ȉ�!���\"!?� ��!�7 ����%����\"���	�
$���!�; ���\"�eb���!���!��`d\"����!)��\"���!)�p �SO��� ������#\")�� ��� ��!��#�� ���#���	
��&+*�" [current-prefix-arg mh-narrowed-to-seq t msg-filename msg-or-seq folder mh-current-folder mh-user-path nil to cc subject trim forw-subject prefix-provided mh-msg-filename file-exists-p format "%sdraft" y-or-n-p "The file 'draft' exists.  Discard it? " mh-exec-cmd "forw" "-build" "-nodraftfolder" mh-read-draft "" mh-insert-fields "To:" "Cc:" set-buffer-modified-p re-search-forward "^------- Forwarded Message" previous-line 1 narrow-to-region mh-get-field "From:" string-match "<" "Subject:" 0 widen "[%s: %s]" delete-other-windows mh-add-msg-list-to-seq mh-seq-to-msgs "forwarded" mh-add-msg-to-seq mh-compose-and-send-mail "F" "Forwarded:"] 31))

(defun mh-goto-msg (number &optional no-error-if-no-message) "\
Position the cursor at message NUMBER.
Non-nil second argument means do not signal an error if message does not exist.
Return non-nil if cursor is at message." (interactive "nMessage number? ") (byte-code "����!`�!� U� łN �) W�) ���#�0 łN �? V�? ���#�F łN eb����#�\\ � ��!�łk 
b�?�i ��\"��+�" [cur-msg nil starting-place msg-pattern number t no-error-if-no-message mh-get-msg-num mh-msg-search-pat re-search-forward re-search-backward beginning-of-line mh-maybe-show error "No message %d "] 10))

(defun mh-inc-folder (&optional maildrop-name) "\
Inc(orporate) new mail into inbox.
Optional prefix argument specifies an alternate maildrop from the default.
If this is given, mail is incorporated into the current folder, rather
than +inbox." (interactive (byte-code "�
 ���	\"!C�" [current-prefix-arg mh-user-path expand-file-name read-file-name "inc mail from file: "] 4)) (byte-code "Ĉ
?� ��!���!?� ?� ��!��
!�" [current-prefix-arg mh-user-path maildrop-name mh-current-folder nil switch-to-buffer "+inbox" boundp mh-make-folder mh-get-new-mail] 5))

(defun mh-kill-folder nil "\
Remove the current folder." (interactive) (byte-code "���\"!�! ��	\"��	!���!��	!)�$ ��!�" [mh-current-folder folder nil yes-or-no-p format "Remove folder %s? " mh-exec-cmd-demon "rmf" mh-remove-folder-from-folder-list message "Folder removed" kill-buffer "Folder not removed"] 8))

(defun mh-list-folders nil "\
List mail folders." (interactive) (byte-code "�����!��ed\"���!����\"�eb���!)��" [t nil " *mh-temp*" switch-to-buffer delete-region message "listing folders..." mh-exec-cmd-output "folders" "listing folders...done"] 7))

(defun mh-msg-is-in-seq (msg) "\
Display the sequences that contain MESSAGE (default: displayed message)." (interactive (byte-code "��!C�" [t mh-get-msg-num] 2)) (byte-code "ň
�	�& 	@A>� ���	@@!#��	A��� ���#*�" [t l mh-seq-list seqs msg nil "" format "%s %s" symbol-name message "Message %d is in sequences: %s"] 6))

(defun mh-move-msg (prefix-provided msg-or-seq dest) "\
Move MESSAGE(s) (default: displayed message) to another FOLDER.
If (optional) prefix argument provided, then prompt for sequence to use
instead of message." (interactive (byte-code "� ��	\"� ��!�����#!E�" [current-prefix-arg mh-narrowed-to-seq t mh-read-seq "Move" mh-get-msg-num intern mh-prompt-for-folder "Destination" ""] 9)) (byte-code "ǈ�B��� ��#� �\"�� �" [current-prefix-arg mh-narrowed-to-seq t mh-last-destination dest prefix-provided msg-or-seq nil move mh-map-to-seq-msgs mh-move-a-msg mh-next-msg] 4))

(defun mh-move-or-write-again (msg) "\
Re-execution the last move or write command on the given MESSAGE (default:
displayed message).
Use the same folder or file as the previous move or write command." (interactive (byte-code "��!C�" [t mh-get-msg-num] 2)) (byte-code "È	?�
 ��!�	@�=�  �
	A\"���	A\"�+ �
	A\"���	A\"�� �" [t mh-last-destination msg nil error "No previous move" move mh-move-a-msg message "Destination folder: %s" mh-write-msg-to-file "Destination: %s" mh-next-msg] 7))

(defun mh-narrow-to-seq (seq) "\
Restrict display of this folder to just messages in a sequence.
Reads which sequence.  Use \\[mh-widen] to undo this command." (interactive (byte-code "��!C�" [mh-read-seq "Narrow to"] 2)) (byte-code "d��!�% �\"��d\"���!!�� ���+ ���!\"*�" [eob buffer-read-only nil seq mh-narrowed-to-seq t mh-seq-to-msgs mh-copy-seq-to-point narrow-to-region mh-make-folder-mode-line symbol-name recenter error "No messages in sequence `%s'"] 10))

(defun mh-next-line (&optional arg) "\
Move to next undeleted message in window." (interactive "p") (byte-code "È�� � �!�ǉ��
��$�& � ����!!�0 ��!�� ���!�" [arg mh-next-direction mh-good-msg-regexp nil t forward-line 1 forward re-search-forward 0 beginning-of-line mh-maybe-show mh-get-msg-num -1 delete-other-windows message "No more messages"] 9))

(defun mh-renumber-folder nil "\
Renumber messages in folder to be 1..N." (interactive) (byte-code "����!�� ���!�� ���!�" [nil message "packing buffer..." mh-pack-folder mh-unmark-all-headers mh-goto-cur-msg "packing buffer...done"] 6))

(defun mh-page-digest nil "\
Advance displayed message to next digested message." (interactive) (byte-code "��!���!������#� ����#?�% ��!���!)�����#���!���!���!)�" [mh-show-buffer case-fold-search nil t switch-to-buffer-other-window move-to-window-line 0 search-forward "

" "From:" other-window -1 error "No more messages." search-backward next-line 2 recenter] 11))

(defun mh-page-digest-backwards nil "\
Back up displayed message to previous digested message." (interactive) (byte-code "��!���!��� �����#� ����#?�( ��!���!)�����#���!���!���!)�" [mh-show-buffer case-fold-search nil t switch-to-buffer-other-window move-to-window-line 0 beginning-of-line search-backward "

" "From:" other-window -1 error "No more messages." next-line 2 recenter] 12))

(defun mh-page-msg (&optional arg) (interactive "P") (byte-code "���!�" [arg nil scroll-other-window] 2))

(defun mh-previous-line (&optional arg) "\
Move to previous undeleted message in window." (interactive "p") (byte-code "ŉ��	��$� ���!!� � ���!�" [mh-next-direction mh-good-msg-regexp nil arg t backward re-search-backward 0 mh-maybe-show mh-get-msg-num delete-other-windows message "Beginning of messages"] 6))

(defun mh-previous-page nil "\
Page the displayed message backwards." (interactive) (byte-code "����!�Î��!))�" [mh-show-buffer nil switch-to-buffer-other-window ((byte-code "��!�" [other-window -1] 2)) scroll-down] 3))

(defun mh-print-msg (prefix-provided msg-or-seq) "\
Print MESSAGE(s) (default: displayed message) on a line printer.
If (optional) prefix argument is supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "� ����	\"!!� ��!CD�" [current-prefix-arg mh-narrowed-to-seq t reverse mh-seq-to-msgs mh-read-seq "Print" mh-get-msg-num] 6)) (byte-code "Ĉ��!�������8 �����#�\"�	�+ ւ3 ��
@#\"%�W ���\"�	�M ւU ��
@#\"$&��h ��#�p �@�#����#���!�" [current-prefix-arg mh-narrowed-to-seq t shell-file-name nil prefix-provided msg-or-seq mh-lib mh-folder-filename mh-lpr-command-format mh-current-folder mh-cmd-note message "printing message..." call-process "-c" format "(scan -clear %s ; %smhl -nobell -clear %s) | %s" mapconcat (lambda (msg) (byte-code "�" [msg] 1)) " " mh-msg-filenames "Mail" "%s/%d" "%smhl -nobell -clear %s | %s" mh-notate-seq 80 mh-notate mh-add-msg-list-to-seq printed "printing message...done"] 23))

(defun mh-put-msg-in-seq (prefix-provided from to) "\
Add MESSAGE(s) (default: displayed message) to SEQUENCE.
If (optional) prefix argument supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "� ���	\"!� ��!��	\"E�" [current-prefix-arg mh-narrowed-to-seq t mh-seq-to-msgs mh-read-seq "Add messages from" mh-get-msg-num "Add to"] 8)) (byte-code "ƈ� �\"� �\"�� �" [current-prefix-arg mh-narrowed-to-seq t prefix-provided from to nil mh-add-msg-list-to-seq mh-add-msg-to-seq mh-next-msg] 4))

(defun mh-rescan-folder (range) "\
Rescan a folder after optionally processing the outstanding commands.
If (optional) prefix argument supplied, prompt for the range of messages to
display.  Otherwise show the entire folder." (interactive (byte-code "�
 ��!� �C�" [current-prefix-arg read-string "Range [all]? " "all"] 2)) (byte-code "Ĉŉ��
\"�" [current-prefix-arg mh-next-direction mh-current-folder range nil forward mh-scan-folder] 3))

(defun mh-redistribute (to cc msg) "\
Redistribute a letter." (interactive (byte-code "��!��!��!E�" [t read-string "Redist-To: " "Redist-Cc: " mh-get-msg-num] 6)) (byte-code "ƈ�
!̋*�" [t msg-filename msg folder mh-current-folder mh-redist-full-contents nil to cc mh-progs mh-user-path mh-msg-filename ((byte-code "���
 	� �\"���!����#���\"?�$ ���#��e��#�� ���!���������	$&��������#&���!�" [mh-redist-full-contents msg-filename nil to cc mh-progs mh-user-path msg folder mh-read-draft "redistribution" mh-goto-header-end 0 insert "Resent-To: " "
" equal "" "Resent-cc: " mh-clean-msg-header "^Message-Id:\\|^Received:\\|Return-Path:" save-buffer message "Redistributing..." call-process "/bin/sh" "-c" format "mhdist=1 mhaltmsg=%s %s/send -push %s/draft" mh-annotate-msg "R" "-component" "Resent:" "-text" "\"%s %s\"" "Redistributing...done"] 21))] 3))

(defun mh-write-msg-to-file (msg file) "\
Append MESSAGE to the end of a FILE." (interactive (byte-code "��!���!!D�" [t mh-get-msg-num expand-file-name read-file-name "Save message in file: "] 5)) (byte-code "ň�
B���!���!q��ed\"��!��ed
#))�" [t mh-last-destination file file-name msg nil write mh-msg-filename get-buffer-create " *mh-temp*" delete-region insert-file-contents append-to-file] 8))

(defun mh-search-folder nil "\
Search the current folder for messages matching a pattern." (interactive) (byte-code "È	��!��� !� ��!?� � � ��!��)�" [folder mh-current-folder mh-searching-folder nil switch-to-buffer-other-window "pick-pattern" zerop buffer-size y-or-n-p "Reuse pattern? " mh-make-pick-template message ""] 8))

(defun mh-send (to cc subject) "\
Compose and send a letter." (interactive "sTo: 
sCc: 
sSubject: ") (byte-code "È� ��	
#�" [to cc subject nil delete-other-windows mh-send-sub] 5))

(defun mh-send-other-window (to cc subject) "\
Compose and send a letter in another window.." (interactive "sTo: 
sCc: 
sSubject: ") (byte-code "ň��
#)�" [pop-up-windows t to cc subject nil mh-send-sub] 4))

(defun mh-send-sub (to cc subject) "\
Do the real work of composing and sending a letter.
Expects the TO, CC, and SUBJECT fields as arguments." (byte-code "��!� 	��!������
\"!� ��
\"�1 ���\"!�. ��\"�1 ��!\"�J ����&���!�db���!����&)�" [folder mh-current-folder mh-user-path mh-lib to subject cc nil boundp message "Composing a message..." mh-read-draft "message" file-exists-p format "%scomponents" error "Can't find components" mh-insert-fields "To:" "Subject:" "Cc:" set-buffer-modified-p "Composing a message...done" mh-compose-and-send-mail ""] 20))

(defun mh-show (msg) "\
Show MESSAGE (default: displayed message)." (interactive (byte-code "��!C�" [t mh-get-msg-num] 2)) (byte-code "�ʉ���!#��!�� ��!��!��� Z!���!�	B�	)�" [t mh-summarize nil mode-name folder mh-current-folder msg mh-show-buffer mh-summary-height mh-seen-list "Mh-Show" mh-display-msg mh-msg-filename switch-to-buffer-other-window delete-other-windows shrink-window window-height recenter 1] 11))

(defun mh-sort-folder nil "\
Sort the messages in the current folder by date." (interactive "") (byte-code "�!�ĉ���!���\"���!���\"�" [mh-current-folder mh-next-direction nil mh-process-commands forward message "sorting folder..." mh-exec-cmd "sortm" "sorting folder...done" mh-scan-folder "all"] 7))

(defun mh-toggle-summarize nil "\
Turn the summary mode of displaying messages on or off." (interactive) (byte-code "È?��� � �ŉ���� �\"!�% ʉ����!!�" [mh-summarize mode-name t nil delete-other-windows "Mh-Summarize" recenter / window-height 2 "Mh-Show" mh-show mh-get-msg-num] 7))

(defun mh-undo (prefix-provided msg-or-seq) "\
Undo the deletion or move of the specified MESSAGE(s)
(default: displayed message).
If (optional) prefix argument is supplied, then prompt for sequence to use
instead of message." (interactive (byte-code "� ��	\"� ��!D�" [current-prefix-arg mh-narrowed-to-seq t mh-read-seq "Undo" mh-get-msg-num] 4)) (byte-code "Ȉ��!�1 � ���!\"���#�. �\"����\"���#�Y ��!�X �J ���!\"���#�U ��\"���#�Y ȇ" [current-prefix-arg mh-narrowed-to-seq t prefix-provided msg-or-seq mh-cmd-note mh-delete-list mh-move-list nil looking-at "^....D" mapc (lambda (msg) (byte-code "�	\"���	�\"�" [mh-delete-list msg delq mh-remove-msg-from-seq deleted] 4)) mh-seq-to-msgs mh-notate-seq 32 delq mh-remove-msg-from-seq deleted mh-notate "^....\\^" (lambda (msg) (byte-code "��\"�" [mh-move-list mapc (lambda (dest) (byte-code "�	\"�" [msg dest mh-remove-msg-from-seq] 3))] 3)) (lambda (dest) (byte-code "�	\"�" [msg-or-seq dest mh-remove-msg-from-seq] 3))] 16))

(defun mh-undo-folder nil "\
Undo all commands in current folder." (interactive "") (byte-code "����!� ���ȉ���!� ��!���!�" [mh-delete-list nil mh-move-list mh-seq-list mh-next-direction t yes-or-no-p "Undo all commands in folder? " forward mh-unmark-all-headers message "Commands not undone." sit-for 2] 5))

(defun mh-visit-folder (folder range) "\
Visit FOLDER and display RANGE of messages." (interactive (byte-code "����#��!D�" [t mh-prompt-for-folder "Visit" "+inbox" read-string "Range [all]? "] 4)) (byte-code "È�	�
�\"� ǂ 
\"�� �" [t folder range nil mh-scan-folder equal "" "all" delete-other-windows] 5))

(defun mh-widen nil "\
Remove restrictions from the current folder, thereby showing all messages." (interactive "") (byte-code "����ed\"�� �� )����" [buffer-read-only nil mh-narrowed-to-seq delete-region widen mh-make-folder-mode-line] 5))

(defun mh-delete-a-msg (msg) "\
Delete the MESSAGE." (byte-code "���\"���!� ��\"�
B�����#���#)�" [msg nil mh-delete-list t mh-cmd-note mh-goto-msg looking-at "....\\^" error "Message %d already moved.  Undo move before deleting." mh-add-msg-to-seq deleted mh-notate 68] 8))

(defun mh-move-a-msg (msg destination) "\
Move the MESSAGE to the FOLDER." (byte-code "���\"���!� ��\"�+ >?� B����#���#)�" [msg nil t destination mh-move-list mh-cmd-note mh-goto-msg looking-at "....D" error "Message %d is already deleted.  Undo delete before moving." mh-add-msg-to-seq mh-notate 94] 8))

(defun mh-display-msg (msg-num msg-filename show-buffer) "\
Display the message NUMBER and PATHNAME in BUFFER." (byte-code "�!?� ��	\"��
!��\"?�v � �� ��ed\"��0 ����$�4 ��\"�eb��J �e#�eb�Z �	����#�� ���!)���!�����!����\"���	\"F��" [msg-filename msg-num show-buffer buffer-file-name mh-use-mhl t mh-clean-message-header mh-invisible-headers mh-visible-headers case-fold-search nil mode-line-buffer-identification folder file-exists-p error "Message %d does not exist." switch-to-buffer equal clear-visited-file-modtime unlock-buffer delete-region mh-exec-lib-cmd-output "mhl" "-nobell" "-noclear" insert-file-contents mh-clean-msg-header re-search-forward "^To:\\|^From:\\|^Subject:\\|^Date:" beginning-of-line recenter 0 set-buffer-modified-p set-mark "mh-e: {%b}  " format "%s" "/" "%d"] 22))

(defun mh-clean-msg-header (start invisible-headers visible-headers) "\
Flush extraneous lines in a message header, from the given POINT to the
end of the message header.  If VISIBLE-HEADERS is non-nil, it contains a
regular expression specifying the lines to display, otherwise INVISIBLE-HEADERS
contains a regular expression specifying lines to delete from the header." (byte-code "�b�����#� ��!��`\"�eb��L `dW�I � ��!�1 ��!�E ��!���!�E � ���!��5 �� �o ���#�o � ���!���!�k � ���!��[ ��L �� )�" [start nil t visible-headers invisible-headers search-forward "

" backward-char 2 narrow-to-region beginning-of-line looking-at forward-line 1 kill-line "^[ 	]+" re-search-forward unlock-buffer] 19))

(defun mh-read-draft (use initial-contents) "\
Read draft file into draft buffer.  USE is a message used for prompting
about the intended use of the message.  INITIAL-CONTENTS is filename that
is read into an empty buffer, or NIL if buffer should not be modified.
Returns T if the buffer is set to the contents of this file, NIL otherwise." (byte-code "��!�� � ��!� ��!� ��!���
\"��� �� ����
\"!�5 ���
\"!��H �� !�H ���\"!?�X �ed\"��!�łY ���!��" [nil buffer-file-name mh-user-path initial-contents use t pop-to-buffer "draft" buffer-modified-p y-or-n-p "Draft is modified; kill anyways? " set-buffer-modified-p error "Draft is not killed." format "%sdraft" clear-visited-file-modtime unlock-buffer file-exists-p insert-file-contents zerop buffer-size "The file 'draft' exists.  Use for %s? " delete-region auto-save-mode 1] 21))

(defun mh-next-msg nil "\
Move backward or forward to the next message in the buffer." (byte-code "�=� ��!� ��!�" [mh-next-direction forward mh-next-line 1 mh-previous-line] 3))

(defun mh-maybe-show (msg) "\
If the scan listing is not summarized, show the message pointed to
by the cursor." (byte-code "?� �	!�" [mh-summarize msg mh-show] 2))

(defun mh-make-folder (name) "\
Create and initialize a new mail folder called NAME and make it the
current folder." (byte-code "�!��p!�� ���ed\"������\"�����O#��������������������&�� �ĉ�߉���!��p!)�" [name buffer-read-only nil mh-user-path t mode-name mh-show-buffer switch-to-buffer buffer-flush-undo kill-all-local-variables delete-region make-local-vars mh-current-folder format "show-%s" mh-folder-filename "%s%s/" 1 mh-summarize mh-next-seq-num 0 mh-delete-list mh-move-list mh-seq-list mh-seen-list mh-next-direction forward mh-narrowed-to-seq mh-first-msg-num mh-last-msg-num mh-folder-mode "Mh-Summarize"] 33))

(defun make-local-vars (&rest pairs) "\
Take VARIABLE-VALUE pairs and makes local variables initialized to the
value." (byte-code "� �@!�@A@L�AA���  �" [pairs make-local-variable] 4))

(defun mh-folder-mode nil "\
Major mode for \"editing\" an MH folder scan listing.
Messages can be marked for refiling and deletion.  However, both actions
are defered until you request execution with \\[mh-execute-commands].
\\{mh-folder-mode-map}
  A prefix argument (\\[universal-argument]) to delete, move, list, or undo applies the action to a message sequence.

Variables controlling mh-e operation are (defaults in parentheses):

 mh-clean-message-header (nil)
    Non-nil means remove header lines matching the regular expression
    specified in mh-invisible-headers from messages.

 mh-use-mhl (nil)
    Non-nil means use mhl to format displayed messages.

 mh-lpr-command-format (\"lpr -p -J '%s'\")
    Format for command used to print a message on a system printer.

 mh-summary-height (4)
    Number of lines in the summary window.

 mh-ins-buf-prefix (\">> \")
    String to insert before each non-blank line of a message as it is
    inserted in a letter being composed." (byte-code "�!�ŉ�Ɖ���!� � �!�" [mh-folder-mode-map major-mode mode-name mh-folder-mode-hook use-local-map mh-folder-mode "mh-folder" boundp funcall] 4))

(defun mh-scan-folder (folder range) "\
Scan the FOLDER over the RANGE.  Return in the folder's buffer." (byte-code "�!?� �!�' 
� �# ��!�! �!�# � ��!��!��ed\"�U�L ��\"�C ��\"�H ��#���!���!�� �" [folder t mh-delete-list mh-move-list range nil get-buffer mh-make-folder y-or-n-p "Process outstanding commands (or lose them)? " mh-process-commands mh-undo-folder switch-to-buffer-other-window mh-regenerate-headers count-lines 0 equal "all" message "Folder %s is empty" "No messages in %s, range %s" sit-for 5 mh-unmark-all-headers mh-goto-cur-msg] 15))

(defun mh-regenerate-headers (range) "\
Replace buffer with scan of its contents over range RANGE." (byte-code "����� \"!�� ��ed\"������� 
&�eb���!�, ��!�5 ��!�5 ��!�� ����� \"!)�" [buffer-read-only nil range t message format "scanning %s..." buffer-name delete-other-windows delete-region mh-exec-cmd-output "scan" "-noclear" "-noheader" looking-at "scan: no messages in" keep-lines "^[ ]*[0-9]" "scan: " mh-make-folder-mode-line "scanning %s...done"] 17))

(defun mh-get-new-mail (maildrop-name) "\
Read new mail from a maildrop into the current buffer.
Return t if there was new mail, nil otherwise.  Return in the current buffer." (byte-code "�`�� ��� #� ��� \"!���!�͉���!�db�`�= ���� ��!�&�A ���\"���P ��� #�U ��� \"!�b���!�� ��!�� �
b����t ݂u ��} �~ �#���� ��!�� � �
b���!���� ��!�� �� ��)*�" [buffer-read-only nil point-before-inc maildrop-name mh-next-direction start-of-inc t message format "inc %s -file %s..." buffer-name "inc %s..." mh-unmark-all-headers forward flush-lines "^inc:\\|^scan:" mh-exec-cmd-output "inc" "-file" expand-file-name "-truncate" "inc %s -file %s...done" "inc %s...done" looking-at "inc: no mail" keep-lines "^[ ]*[0-9]" mh-make-folder-mode-line "No new mail%s%s." " in " "" "inc:" "inc error" mh-goto-cur-msg] 27))

(defun mh-make-folder-mode-line (&optional annotation) "\
Set the fields of the mode line for a folder buffer.
The optional ANNOTATION string is displayed after the folder's name." (byte-code "�eb���!���ed\"�db���!���!�����- ��\"�. �

�U�9 ЂK 
�V�G ��#�K ��\"$C�*)�" [mh-first-msg-num nil lines case-fold-search mh-last-msg-num mode-line-buffer-identification annotation mh-get-msg-num count-lines previous-line 1 format "mh-e: {%%b%s}  [%d message%s]" "/%s" "" 0 "s" "s (%d - %d)" " (%d)"] 13))

(defun mh-unmark-all-headers (remove-all-flags) "\
Remove all + flags from the headers, and if called
with a non-nil argument, remove all D and ^ flags too." (byte-code "���eb�� ����#� ����#�& ��!��c�� *)�" [buffer-read-only nil case-fold-search remove-all-flags t re-search-forward "^....\\D\\|^....\\^\\|^....\\+\\|.....%" "^....\\+" delete-backward-char 1 " "] 5))

(defun mh-goto-cur-msg nil "\
Position the cursor at the current message." (byte-code "�	!�!� ��\"?� db���!���!�, ���#���!��!)�" [curmsg mh-current-folder t mh-get-cur-msg zerop mh-goto-msg forward-line -1 message "No current message" mh-notate 43 4 recenter 0 mh-maybe-show] 9))

(defun mh-pack-folder nil "\
Close and pack the current folder." (byte-code "���!��
!���!�����
�$)���!���!)�" [buffer-read-only nil mh-current-folder message "closing folder..." mh-process-commands "packing folder..." mh-exec-cmd-quiet " *mh-temp*" "folder" "-pack" mh-regenerate-headers "all" "packing done"] 8))

(defun mh-process-commands (buffer) "\
Process outstanding commands for the buffer BUFFER." (byte-code "��!�q���!��. ��!?� Љ������E��E#\")���\"��L ������\"D\"\"��!���!�c ����!����&�t � �V�t ������&��	q�
)����)���!�" [buffer buffer-read-only nil mh-seq-list mh-seen-list unseen-seq mh-current-folder mh-move-list mh-delete-list mh-show-buffer buffer-file-name message "Processing deletes and moves..." mh-process-seq-commands mh-get-profile-field "Unseen-Sequence:" "unseen" apply mh-exec-cmd-quiet nconc 0 "mark" "-sequence" "-delete" mapc (lambda (dest) (byte-code "�	!� �!�����B�
�	!E\"\")�" [msgs dest buffer mh-seq-to-msgs mh-delete-scan-msgs apply mh-exec-cmd nconc "refile" "-src" symbol-name] 10)) mh-exec-cmd "rmm" format "%s" mh-delete-scan-msgs mh-get-msg-num "-seq" "cur" "-add" "-zero" buffer-size "all" "Processing deletes and moves...done"] 21))

(defun mh-delete-scan-msgs (msgs) "\
Delete the scan listing lines for each of the msgs in the LIST." (byte-code "�eb�����#!)�" [msgs flush-lines mapconcat mh-msg-search-pat "\\|"] 5))

(defun mh-letter-mode nil "\
Mode for composing letters in mh-e.
\\{mh-letter-mode-map}" (byte-code "� ���!��P����!��	P���
!�ʉ�ˉ���!�* �0 �!�" [paragraph-start paragraph-separate mh-letter-mode-map major-mode mode-name mh-letter-mode-hook text-mode make-local-variable "^[ 	]*[-_][-_][-_]+$\\|" use-local-map mh-letter-mode "mh-letter" boundp funcall] 7))

(defun mh-to-field nil "\
Move point to the end of the header field indicated by the previous
keystroke.Create the field if it does not exist.  Set the mark to the
point before moving." (interactive "") (byte-code "È� ��	�\"A��\"� ��!?� ��!�4 eb���!���!����\"!���!)�" [target last-input-char t nil expand-abbrev assoc ((116 . "To:") (115 . "Subject:") (99 . "Cc:") (98 . "Bcc:") (102 . "Fcc:")) mh-position-on-field looking-at "[ 	]" insert-string " " re-search-forward "^To:" forward-line 1 format "%s 
" backward-char] 11))

(defun mh-insert-signature nil "\
Insert the file ~/.signature at the current point" (interactive "") (byte-code "����!�" [nil insert-file-contents "~/.signature"] 2))

(defun mh-check-whom nil "\
List recipients of the current letter." (interactive) (byte-code "� ��!�� ���!���!��p!��ed\"����#���!���!)�" [file-name t nil buffer-file-name set-buffer-modified-p save-buffer message "Checking recipients..." switch-to-buffer-other-window "*Mail Recipients*" bury-buffer delete-region mh-exec-cmd-output "whom" other-window -1 "Checking recipients...done"] 11))

(defun mh-make-pick-template nil "\
Initialize the current buffer with a template for a pick pattern." (byte-code "�ed\"�� ���!��������&�� ��!��C��eb�� �" [mh-pick-mode-map mode-line-buffer-identification delete-region kill-all-local-variables make-local-variable mh-searching-folder insert "From: 
" "To: 
" "Cc: 
" "Date: 
" "Subject: 
" "---------
" mh-letter-mode use-local-map "mh-e: {%b}  Pick Pattern" end-of-line] 10))

(defun mh-do-pick-search nil "\
Find messages in current folder matching qualifications in current buffer.
Put messages found in a sequence named `search'." (interactive) (byte-code "Ĉ� 
���	q���#�)���!�eb��!��D �	���B�	���%\"#��։��! ���!��	!�� ����	�\\#,�" [pattern-buffer searching-buffer mh-searching-folder range nil pattern mh-first-msg-num mh-last-msg-num msgs mh-cmd-note buffer-name format "%d-%d" message "Searching..." mh-next-pick-field mh-seq-from-command search nconc "pick" list "-sequence" "search" "-list" "Searching...done" switch-to-buffer delete-other-windows mh-notate-seq 37 1] 16))

(defun mh-next-pick-field (buffer) "\
Return the next piece of a pick argument that can be extracted from the
BUFFER.  Returns nil if no pieces remain." (byte-code "q��m� Âg ����#�7 ������!��!\"!\"���!��!\"��!�D*�g ����#�f ��!��`d\"G�V�W ��\"?�a �D�b �)�g �)�" [buffer case-fold-search t nil component pat body re-search-forward "^\\([a-z].*\\):[ 	]*\\([a-z0-9].*\\)$" format "-%s" downcase buffer-substring match-beginning 1 match-end 2 forward-line "^-*$" forward-char 0 equal "
" "-search"] 16))

(defun mh-compose-and-send-mail (send-args sent-from-folder sent-from-msg to subject cc &optional annotate-char annotate-field search-prefix) "\
Edit and compose a draft message and send or save it.
SENT-FROM-FOLDER is buffer containing scan listing of current folder, or
nil if none exists.
SENT-FROM-MSG is the message number or sequence name or nil.
SEND-ARGS is an optional argument passed to the send command.
The TO, SUBJECT, and CC fields are passed to the mh-compose-letter-hook.
If ANNOTATE-CHAR is non-null, it is used to notate the scan listing of the
message.  In that case, the ANNOTATE-FIELD is used to build a string
for mh-annotate-msg." (byte-code "��!�� ����	�
���� � �&��C����!�- �: �	
$�" [send-args sent-from-folder sent-from-msg annotate-field annotate-char search-prefix mode-line-buffer-identification mh-compose-letter-hook to subject cc pop-to-buffer "draft" mh-letter-mode make-local-vars mh-send-args mh-sent-from-folder mh-sent-from-msg mh-annotate-field mh-annotate-char mh-annotate-search-prefix "" "mh-e: {%b}  Mail/draft" boundp funcall] 15))

(defun mh-send-letter (&optional arg) "\
Send the draft letter in the current buffer.
If (optional) prefix argument supplied, monitor delivery." (interactive "P") (byte-code "̈��!�� ���!�� � �= ��!��ed\"��1 ������
&�: ������
&�T �M �����
&�T �����
%��x ��������	�#!���	�#!#&�?�� ��!�� 
�	!�
�� � ��
!��� �!*���!*�" [t buffer-name file-name arg mh-send-args mh-annotate-char mh-sent-from-msg mh-sent-from-folder mh-annotate-field mh-annotate-search-prefix sent-from-folder sent-from-msg nil set-buffer-modified-p save-buffer message "Sending..." buffer-file-name pop-to-buffer "MH mail delivery" kill-region mh-exec-cmd-output "send" "-watch" "-unique" "-nodraftfolder" mh-exec-cmd-demon "-noverbose" mh-annotate-msg "-component" "-text" format "\"%s %s\"" mh-get-field "%s%s" "To:" "Cc:" y-or-n-p "Kill draft buffer? " kill-buffer delete-other-windows switch-to-buffer mh-maybe-show "Sending...done"] 28))

(defun mh-insert-letter (prefix-provided folder msg) "\
Insert a message from any folder into the current letter.
Removes the message's headers using mh-invisible-headers.
Prefixes each non-blank line with mh-ins-buf-prefix (default \">> \").
If (optional) prefix argument supplied, do not indent and do not delete
headers.
Leaves the point before the letter and the mark after it." (interactive (byte-code "��	�#���� ��\"� �\"!E�" [current-prefix-arg mh-sent-from-folder nil mh-sent-from-msg mh-prompt-for-folder "Message from" read-input format "Message number%s: " " [%d]" ""] 9)) (byte-code "`��\"� ��\"����������O$$�?�> �	
#��� \"��!�� �� )�" [current-prefix-arg mh-sent-from-folder nil mh-sent-from-msg start msg mh-user-path folder prefix-provided mh-invisible-headers mh-visible-headers mh-ins-buf-prefix equal "" format "%d" mh-exec-lib-cmd-output "mhl" "-nobell" "-noclear" "%s%s/%s" 1 mh-clean-msg-header narrow-to-region mark mh-insert-prefix-string widen exchange-point-and-mark] 12))

(defun mh-insert-cur-msg nil "\
Insert the currently displayed message into the current draft buffer.
Prefixes each non-blank line with the string mh-ins-buf-prefix.
If there is a region set in the  message's buffer, only the region will
be inserted.  Otherwise, the region from (point) to the end of the draft
buffer will be grabbed." (interactive) (byte-code "ǈ��!� � 	�D `pq�q�� �' �`� \"�+ �`d\"q��

\"��!��!�� )*�G ��!�" [mh-sent-from-folder mh-sent-from-msg to-point to-buffer mh-show-buffer mh-ins-str mh-ins-buf-prefix nil boundp mark buffer-substring narrow-to-region insert-string mh-insert-prefix-string widen error "There is no current message."] 11))

(defun mh-insert-prefix-string (ins-string) "\
Preface each line in the current buffer with STRING." (byte-code "eb�m?� �!���!�� �eb�" [ins-string insert-string forward-line 1] 4))

(defun mh-fully-kill-draft nil "\
Kill the draft message file and the draft message buffer.
Use \\[kill-buffer] if you don't want to delete the draft message file." (interactive "") (byte-code "Ĉ��!�7 	�� !� �� !���!��� !��3 � ��!�
�3 �
!*�: ��!�" [sent-from-folder mh-sent-from-folder sent-from-msg mh-sent-from-msg nil y-or-n-p "Kill draft message? " file-exists-p buffer-file-name delete-file set-buffer-modified-p kill-buffer buffer-name delete-other-windows switch-to-buffer mh-maybe-show error "Message not killed"] 13))

(defmacro mh-seq-name (pair) (byte-code "�D�" [pair car] 2))

(defmacro mh-seq-msgs (pair) (byte-code "�D�" [pair cdr] 2))

(defun mh-seq-to-msgs (seq) "\
Return the messages in sequence SEQ." (byte-code "�	\"A�" [seq mh-seq-list assoc] 3))

(defun mh-msg-to-seq (msg) "\
Given a MESSAGE number, return the first sequence in which it occurs." (byte-code "	� 
@A>?� A��� �@@)�" [l mh-seq-list msg] 3))

(defun mh-read-seq (prompt &optional default) "\
Read and return a sequence name from the minibuffer, prompting with
the string PROMPT and supplying the optional DEFAULT.
% defaults to the sequences containing the current message.
Makes sure that the sequence is known to MH commands." (byte-code "���	�
� ���
!\"� �$�!\"��\"�( ���!!�6 ��\"�3 
�6 �!��!\"�))�" [input prompt default mh-seq-list seq t completing-read format "%s %s %s" "sequence:" "[%s] " symbol-name "" mh-seq-names equal "%" mh-msg-to-seq mh-get-msg-num intern mh-process-seq mh-seq-to-msgs] 14))

(defun mh-seq-names (seq-list) "\
Return an alist of the names of the SEQUENCES." (byte-code "��\"�" [seq-list mapcar (lambda (entry) (byte-code "�@!�B�" [entry nil symbol-name] 3))] 3))

(defun mh-seq-from-command (folder seq command) "\
In FOLDER, make a sequence named SEQ by executing COMMAND." (byte-code "���ɋ�q��!��BB��)*�" [msgs nil case-fold-search t command num folder mh-seq-list seq ((byte-code "���B\"�eb�����#�. ����!��!\"!�!?�) B�)��
 �" [command nil t num msgs apply mh-exec-cmd-quiet " *mh-temp*" re-search-forward "\\([0-9]+\\)" string-to-int buffer-substring match-beginning 1 match-end zerop] 10)) nreverse] 3))

(defun mh-remove-seq (seq) "\
Delete the sequence SEQ." (byte-code "�	
\"�	��\\#��
\"�)�" [entry seq mh-seq-list mh-cmd-note assoc mh-notate-seq 32 1 delq] 6))

(defun mh-remove-msg-from-seq (msg seq &optional do-not-mark) "\
Remove MESSAGE from the sequence SEQ.  If optional FLAG is
non-nil, do not mark the message as being part of a sequence." (byte-code "�	\"� ��
A\"\")�?� �
��\\#�" [seq mh-seq-list msg do-not-mark mh-cmd-note assoc setcdr delq mh-notate 32 1] 8))

(defun mh-add-msg-to-seq (msg seq &optional do-not-mark) "\
Add MESSAGE to the SEQUENCE.  If optional FLAG is non-nil,
do not mark the message as being part of a sequence." (byte-code "�	
\"?� ���\\#�?�\" 	CB
B��) �AB\")�" [seq-list seq mh-seq-list do-not-mark msg mh-cmd-note assoc mh-notate 37 1 setcdr] 6))

(defun mh-add-msg-list-to-seq (msgs seq &optional do-not-mark) "\
Add the messages in LIST to the SEQUENCE.  If optional FLAG is non-nil,
do not mark the messages as being part of a sequence." (byte-code "��\"�" [msgs mapc (lambda (msg) (byte-code "�	
#�" [msg seq do-not-mark mh-add-msg-to-seq] 4))] 3))

(defun mh-rename-seq (seq new-name) "\
Rename a SEQUENCE to have a new NAME." (interactive "SOld sequence name: 
SNew name: ") (byte-code "Ĉ�	
\"� �\"� ���	!\")�" [old-seq seq mh-seq-list new-name nil assoc rplaca error "Sequence %s does not exists" symbol-name] 6))

(defun mh-notate-seq (seq notation offset) "\
Mark all messages in the sequence SEQ with the NOTATION at character
OFFSET." (byte-code "��	
$�" [seq notation offset mh-map-to-seq-msgs mh-notate] 5))

(defun mh-map-to-seq-msgs (func seq &rest args) "\
Invoke the function FUNC at each message in the sequence SEQ, passing
the remaining ARGS as arguments." (byte-code "�	!� �@!��
@B\"�A��� )�" [msgs seq func args mh-seq-to-msgs mh-goto-msg apply] 7))

(defun mh-map-over-seqs (func seq-list) "\
Apply the function FUNC to each element in the sequence LIST,
passing the sequence name and a list of messages as arguments." (byte-code "� �	@@@A#�A���  �" [seq-list func funcall] 5))

(defun mh-process-seq-commands (seq-list) "\
Process outstanding sequence commands for the sequences in SEQ-LIST." (byte-code "��\"�" [seq-list mh-map-over-seqs mh-process-seq] 3))

(defun mh-process-seq (seq msgs) "\
Mark sequence SEQ to contain MSGS." (byte-code "��!��O�\"?�# 	�# �����
����\"�&	\"\"�" [seq msgs mh-current-folder equal symbol-name 0 1 "+" apply mh-exec-cmd nconc list "mark" "-zero" "-seq" format "%s" "-add"] 13))

(defun mh-copy-seq-to-point (seq location) "\
Copy the messages in SEQUENCE to after the LOCATION in the current buffer." (byte-code "��	#�" [seq location mh-map-to-seq-msgs mh-copy-line-to-point] 4))

(defun mh-copy-line-to-point (msg location) "\
Copy the current line to the LOCATION in the current buffer." (byte-code "� �`��!��`\"�	b�� �b)�" [beginning-of-line location forward-line 1 copy-region-as-kill yank] 5))

(defun mh-exec-cmd (command &rest args) "\
Execute MH command COMMAND with ARGS.  Any output is shown to the user." (byte-code "ŋ�" [mh-progs command nil t args ((byte-code "��!��ed\"������	#���F�!\"\"�� �V�% ��!�" [mh-progs command nil t args switch-to-buffer-other-window " *mh-temp*" delete-region apply call-process nconc format "%s%s" mh-list-to-string buffer-size 0 sit-for 5] 10))] 1))

(defun mh-exec-cmd-quiet (buffer command &rest args) "\
In BUFFER, execute MH command COMMAND with ARGS.  Return in buffer, if
one exists." (byte-code ";� �!��ed\"������	
#��F�!\"\"�" [buffer mh-progs command nil args switch-to-buffer delete-region apply call-process nconc format "%s%s" mh-list-to-string] 10))

(defun mh-exec-cmd-output (command display &rest args) "\
Execute MH command COMMAND with DISPLAY flag and ARGS putting the output
into buffer after point.  Set mark after inserted text." (byte-code "�`�\"������	
#��F�!\"\"�� �" [t mh-progs command nil display args push-mark apply call-process nconc format "%s%s" mh-list-to-string exchange-point-and-mark] 9))

(defun mh-exec-cmd-demon (command &rest args) "\
Execute MH command COMMAND with ARGS.  Any output from command is displayed
in an asynchronous pop-up window." (byte-code "������
\"E�!\"\"��\")�" [process nil command mh-progs args apply start-process nconc "mh-output" expand-file-name mh-list-to-string set-process-filter mh-process-demon] 8))

(defun mh-process-demon (process output) "\
Process demon that puts output into a temporary buffer." (byte-code "��!�c���!�" [output pop-to-buffer " *mh-temp*" sit-for 2] 3))

(defun mh-exec-lib-cmd-output (command &rest args) "\
Execute MH library command COMMAND with ARGS.  Put the output into
buffer after point.  Set mark after inserted text." (byte-code "�`�\"������	
#���F�!\"\"�� �" [t mh-lib command nil args push-mark apply call-process nconc format "%s%s" mh-list-to-string exchange-point-and-mark] 9))

(defun mh-list-to-string (l) "\
Flattens the list L and makes every element of the new list into a string." (byte-code "�
�j 
@?�a 
@9� ��
@\"B��a �
@!�1 ��
@\"B��a �
@�\"�a 
@;�H 
@B��a 
@<�\\ ���
@!!\"��a ��
@\"�
A��� ��!)�" [new-list nil l t format "%s" numberp "%d" equal "" nconc nreverse mh-list-to-string error "Bad argument %s"] 11))

(defun mh-annotate-msg (msg buffer note &rest args) "\
Mark the MESSAGE in BUFFER listing with the character NOTE and annotate
the saved message with ARGS." (byte-code "���	
BBB\"��q�	9� �	�\\#�% �	�\\#)�" [buffer msg args note mh-cmd-note apply mh-exec-cmd "anno" mh-notate-seq 1 mh-notate] 7))

(defun mh-notate (msg notation offset) "\
Marks MESSAGE with the character NOTATION at position OFFSET." (byte-code "���\"� �� �`\\b���!�c))�" [msg t buffer-read-only nil offset notation mh-goto-msg beginning-of-line delete-char 1] 4))

(defun mh-prompt-for-folder (prompt default can-create) "\
Prompt for a folder name with PROMPT.  Returns the folder's name.
DEFAULT is used if the folder exists and the user types return.
If the CAN-CREATE flag is t, then a non-existant folder is made." (byte-code "����	\"� ̂ ��	\"#�?� � ������%��7 �
�\"�7 �	�\"�? Ĉ�  ��
�\"�K �
�\"�T 	��e �
��O�\"?�e ��
\"�����
��O#!?�} ���
\"!�� ��
\"��������
��O#%���
\"�
CB��
��OCB��� �� ��!�� �
\"?�� 
CB��
��OCB�)�
*�" [prompt default name mh-folder-list nil new-file-p mh-user-path t format "%s folder%s" equal "" "? " " [%s]? " mh-make-folder-list completing-read "+" 0 1 "+%s" file-exists-p "%s%s" y-or-n-p "Folder %s does not exist. Create it? " message "Creating %s" call-process "mkdir" "Creating %s...done" error assoc] 27))

(defun mh-make-folder-list nil "\
Return a list of the user's folders.
Result is in a form suitable for completing read." (interactive) (byte-code "��ŋ�" [list nil start t folder ((byte-code "�����$�eb��m?�/ `����#��
`�Z\"��\"CB�))�� �)�" [list nil start t folder mh-exec-cmd-quiet " *mh-temp*" "folders" "-fast" "-norecurse" search-forward "
" buffer-substring 1 format "+%s"] 7))] 1))

(defun mh-remove-folder-from-folder-list (folder) "\
Remove FOLDER from the list of folders." (byte-code "��	��O\"\"��" [mh-folder-list folder nil delq assoc 1] 5))

(defun mh-get-msg-num (error-if-no-message) "\
Return the message number of the displayed message.  If the argument
ERROR-IF-NO-MESSAGE is non-nil, then complain if the cursor is not
pointing to a message." (byte-code "�� ���!� ����!��!\"!�\" �! ��!�\" �)�" [error-if-no-message t nil beginning-of-line looking-at "^[ ]*\\([0-9]+\\)" string-to-int buffer-substring match-beginning 1 match-end error "Cursor not pointing to message"] 8))

(defun mh-msg-search-pat (n) "\
Return a search pattern for message N in the scan listing." (byte-code "�W� ��\"�+ �W� ��\"�+ �W�' ��\"�+ ��\"�" [n t 10 format "^[^0-9][^0-9][^0-9]%d" 100 "^[^0-9][^0-9]%d" 1000 "^[^0-9]%d" "^%d"] 6))

(defun mh-msg-filename (msg) "\
Returns a string containing the file name of the MESSAGE." (byte-code "��	#�" [mh-folder-filename msg format "%s%d"] 4))

(defun mh-msg-filenames (msgs folder) "\
Return a string of filenames for MSGS in FOLDER." (byte-code "���#�" [msgs mapconcat (lambda (msg) (byte-code "	P�" [folder msg] 2)) " "] 4))

(defun mh-find-path nil "\
Set mh-user-path to the user's Mail directory from  ~/.mh_profile." (byte-code "���!��\"� ŉ� ��\"�����O�\"?�, ����!#��" [mh-user-path equal mh-get-profile-field "Path:" "" "Mail/" format "%s/" 0 1 "/" "%s/%s" getenv "HOME"] 9))

(defun mh-get-profile-field (field) "\
Return FIELD from the user's .mh_profile file." (byte-code "���" [field ((byte-code "��!?�
 ��!���!��ed\"����!!��!�" [field file-exists-p "~/.mh_profile" error "Cannot find ~/.mh_profile file.  Run mh-install!" switch-to-buffer " *mh_temp*" delete-region insert-file-contents expand-file-name mh-get-field] 8))] 1))

(defun mh-get-cur-msg (folder) "\
Return the number of the 'cur' message in FOLDER." (byte-code "��q��ed\"����	�$���ed\"!)�" [nil folder " *mh_temp*" delete-region mh-exec-cmd-output "pick" "cur" string-to-int buffer-substring] 6))

(defun mh-get-field (field) "\
Find and return the value of field FIELD in the current buffer.
Returns the empty string if the field is not in the message." (byte-code "�eb��
��#?� ƂK ��!� ƂK ����#����!��!\"`� ���!�= ��!��0 ���!���
�`\"#*)�" [case-fold-search t field nil end-of-match search-forward "" looking-at "[	 ]*$" re-search-forward "[	 ]*\\([^	 
].*\\)$" buffer-substring match-beginning 1 match-end forward-line "[ 	]" backward-char format "%s%s"] 16))

(defun mh-insert-fields (&rest name-values) "\
Insert the NAME-VALUE pairs in the current buffer.
Do not insert any pairs whose value is the empty string." (byte-code "�
�C 
@
A@��\"?�8 eb����\"��#?�1 ��!����$�8 � ���\"�
AA�*�� )�" [case-fold-search t name-values field-name value nil equal "" re-search-forward format "^%s" mh-goto-header-end 0 insert " " "
" end-of-line] 10))

(defun mh-position-on-field (field set-mark) "\
Set point to the end of the line beginning with FIELD.
Set the mark to the old value of point, if SET-MARK is non-nil." (byte-code "� � �eb���!����	\"��#�  � �Â! " [set-mark field nil t push-mark mh-goto-header-end 0 re-search-backward format "^%s" end-of-line] 7))

(defun mh-goto-header-end (arg) "\
Find the end of the message header in the current buffer and position
the cursor at the ARG'th newline after the header." (byte-code "����#� �	!�" [nil arg re-search-forward "^$\\|^-+$" forward-line] 4))

(define-key mh-folder-mode-map "?" (quote mh-msg-is-in-seq))

(define-key mh-folder-mode-map "%" (quote mh-put-msg-in-seq))

(define-key mh-folder-mode-map "%" (quote mh-delete-msg-from-seq))

(define-key mh-folder-mode-map "n" (quote mh-narrow-to-seq))

(define-key mh-folder-mode-map "w" (quote mh-widen))

(define-key mh-folder-mode-map "b" (quote mh-burst-digest))

(define-key mh-folder-mode-map "u" (quote mh-undo-folder))

(define-key mh-folder-mode-map " " (quote mh-page-digest))

(define-key mh-folder-mode-map "" (quote mh-page-digest-backwards))

(define-key mh-folder-mode-map "e" (quote mh-extract-rejected-mail))

(define-key mh-folder-mode-map "f" (quote mh-visit-folder))

(define-key mh-folder-mode-map "k" (quote mh-kill-folder))

(define-key mh-folder-mode-map "l" (quote mh-list-folders))

(define-key mh-folder-mode-map "p" (quote mh-renumber-folder))

(define-key mh-folder-mode-map "s" (quote mh-search-folder))

(define-key mh-folder-mode-map "r" (quote mh-rescan-folder))

(define-key mh-folder-mode-map "l" (quote mh-print-msg))

(define-key mh-folder-mode-map "t" (quote mh-toggle-summarize))

(define-key mh-folder-mode-map "c" (quote mh-copy-msg))

(define-key mh-folder-mode-map ">" (quote mh-write-msg-to-file))

(define-key mh-folder-mode-map "i" (quote mh-inc-folder))

(define-key mh-folder-mode-map "x" (quote mh-execute-commands))

(define-key mh-folder-mode-map "e" (quote mh-execute-commands))

(define-key mh-folder-mode-map "r" (quote mh-redistribute))

(define-key mh-folder-mode-map "f" (quote mh-forward))

(define-key mh-folder-mode-map "s" (quote mh-send))

(define-key mh-folder-mode-map "a" (quote mh-answer))

(define-key mh-folder-mode-map "g" (quote mh-goto-msg))

(define-key mh-folder-mode-map "" (quote mh-previous-page))

(define-key mh-folder-mode-map " " (quote mh-page-msg))

(define-key mh-folder-mode-map "." (quote mh-show))

(define-key mh-folder-mode-map "u" (quote mh-undo))

(define-key mh-folder-mode-map "!" (quote mh-move-or-write-again))

(define-key mh-folder-mode-map "^" (quote mh-move-msg))

(define-key mh-folder-mode-map "d" (quote mh-delete-msg))

(define-key mh-folder-mode-map "p" (quote mh-previous-line))

(define-key mh-folder-mode-map "n" (quote mh-next-line))

(define-key mh-letter-mode-map "b" (quote mh-to-field))

(define-key mh-letter-mode-map "c" (quote mh-to-field))

(define-key mh-letter-mode-map "f" (quote mh-to-field))

(define-key mh-letter-mode-map "s" (quote mh-to-field))

(define-key mh-letter-mode-map "t" (quote mh-to-field))

(define-key mh-letter-mode-map "" (quote mh-fully-kill-draft))

(define-key mh-letter-mode-map "" (quote mh-check-whom))

(define-key mh-letter-mode-map "	" (quote mh-insert-letter))

(define-key mh-letter-mode-map "" (quote mh-insert-cur-msg))

(define-key mh-letter-mode-map "" (quote mh-insert-signature))

(define-key mh-letter-mode-map "" (quote mh-send-letter))

(define-key mh-pick-mode-map "" (quote mh-do-pick-search))

(define-key mh-pick-mode-map "b" (quote mh-to-field))

(define-key mh-pick-mode-map "c" (quote mh-to-field))

(define-key mh-pick-mode-map "f" (quote mh-to-field))

(define-key mh-pick-mode-map "s" (quote mh-to-field))

(define-key mh-pick-mode-map "t" (quote mh-to-field))

(define-key mh-pick-mode-map "" (quote mh-check-whom))
